#include "registro_mod_paciente.h"
#include "ui_registro_mod_paciente.h"
#include <QDebug>
#include <QDjangoWhere.h>
#include <QDjangoQuerySet.h>
#include <QtSql>
#include <QMessageBox>
#include <QStyle>
#include <QDesktopWidget>


Registro_mod_paciente::Registro_mod_paciente(QWidget *parent,Paciente *pac):QDialog(parent),ui(new Ui::Registro_mod_paciente)
{
        ui->setupUi(this);

        this->setWindowFlags(Qt::Tool);
        this->setGeometry(QStyle::alignedRect(Qt::LeftToRight, Qt::AlignCenter, this->size(), qApp->desktop()->availableGeometry()));
        band = false;

        //***Validaciones**//
        validatorS = new QRegExpValidator(QRegExp("[^0-9]{40}"),this);
        ui->nombre->setValidator(validatorS);
        ui->apellido->setValidator(validatorS);
        ui->direccion->setValidator(validatorS);
        ui->direccionf->setValidator(validatorS);
        validatorN = new QIntValidator(1, 99999999);
        ui->cedula->setValidator(validatorN);


        ui->idPaciente->setVisible(false);

        QDjangoQuerySet<Patologia> pat;
        QDjangoQuerySet<GrupoPoblacional> grupo;

        if(pat.count() > 0){
             foreach(const Patologia &pato, pat) {ui->patologia->addItem(pato.getDescripcion());}
        }

        if(grupo.count() > 0){
            foreach(const GrupoPoblacional &grupopob, grupo) {ui->grupo->addItem(grupopob.getDescripcion());}
        }

        if(pac != NULL){
            QDjango::setDebugEnabled(true);
            band = true;
            ui->cedula->setText(QString::number(pac->getCedula()));                    
            ui->ruc->setText(pac->getRuc());
            ui->nombre->setText(pac->getNombre());
            ui->apellido->setText(pac->getApellido());
            ui->sexo->setCurrentText(pac->getSexo());
            ui->telefono->setText(pac->getTelefono());
            ui->direccion->setText(pac->getDireccion());
            ui->direccionf->setText(pac->getDir_facturacion());
            ui->email->setText(pac->getEmail());
            ui->patologia->setCurrentText(pac->getPatologia()->getDescripcion());
            ui->grupo->setCurrentText(pac->getGrupopoblacional()->getDescripcion());
            ui->fecha->setDate(pac->getFecha_nac());
            ui->idPaciente->setText(QString::number(pac->getIdPaciente()));

            if (ui->telefono->text().isEmpty() || ui->ruc->text().isEmpty()){ui->telefono->setInputMask("999#-999-999");ui->ruc->setInputMask("999999##-9");}
            else this->setWindowTitle("Modificar Paciente");

        }else{
            ui->idPaciente->setText("");
            ui->telefono->setInputMask("999#-999-999");
            ui->ruc->setInputMask("999999#-9#");
            this->setWindowTitle("Registrar Paciente");
        }


}

Registro_mod_paciente::~Registro_mod_paciente()
{
    delete ui;
}

void Registro_mod_paciente::on_aceptar_clicked()
{

      QDjango::setDebugEnabled(true);

      if(ui->cedula->text().simplified() == "" || ui->nombre->text().simplified() == "" || ui->apellido->text().simplified() == "" ||
         ui->ruc->text().simplified() == "-"|| ui->telefono->text().simplified() == "--"){

         if(ui->nombre->text().simplified() == ""){
              ui->nombre->setFocus();
              QToolTip::showText(ui->nombre->mapToGlobal(QPoint(10,8)), "Campo Obligatorio");
          }
          else if(ui->apellido->text().simplified() == "")
          {
              ui->apellido->setFocus();
              QToolTip::showText(ui->apellido->mapToGlobal(QPoint(10,8)), "Campo Obligatorio");
          }
          else if(ui->cedula->text().simplified() == "")
          {
              ui->cedula->setFocus();
              QToolTip::showText(ui->cedula->mapToGlobal(QPoint(10,8)), "Campo Obligatorio");
          }
          else if(ui->ruc->text().simplified() == "-")
          {
              ui->ruc->setFocus();
              QToolTip::showText(ui->ruc->mapToGlobal(QPoint(10,8)), "Campo Obligatorio");

          }else if(ui->telefono->text().simplified() == "--")
          {
             ui->telefono->setFocus();
             QToolTip::showText(ui->telefono->mapToGlobal(QPoint(10,8)), "Campo Obligatorio");

          }
      }

     else if(!rucEsValido(ui->ruc->text()))
              cuadroMensaje("", "Ruc invalido. Verifique el RUC ingresado", "Error");

      else if(ui->email->text().simplified() != "" && !emailEsValido(ui->email->text()))
              cuadroMensaje("", "Error en el campo correo");

      else{            

          if(!band && existeEnLaBD("paciente", "ruc", ui->ruc->text()))
          {
              int var = 0;
              QDjangoQuerySet<Paciente> pacientes;
              Paciente *pacCons = pacientes.filter(QDjangoWhere("ruc", QDjangoWhere::Equals, ui->ruc->text())).at(0);

              if(pacCons->getEstado() == "inactivo"){
                  var = cuadroMensaje("", "El paciente se encuentra como inactivo en la base de datos. Desea volver a ponerlo activo?", "pregunta");
                  if(var == QMessageBox::Ok){
                      pacCons->setEstado("activo");
                      pacCons->save();
                      this->close();
                  }
              }
              else cuadroMensaje("Error en el Registro", "Ya se encuentra registrado un paciente con ese ruc", "error");
              delete pacCons;
          }
          else
          {

              QDjangoQuerySet<Patologia> pat;
              QDjangoQuerySet<GrupoPoblacional> grupo;
              pat = pat.filter(QDjangoWhere("id_patologia",QDjangoWhere::Equals,(ui->patologia->currentIndex())+1));
              grupo = grupo.filter(QDjangoWhere("id_grupopoblacional",QDjangoWhere::Equals,(ui->grupo->currentIndex())+1));

            Paciente *paci = new Paciente();
            if (ui->idPaciente->text() != "")
            {
                paci->setIdPaciente(ui->idPaciente->text().toInt());
            }
            else{

                 QSqlQuery query;
                 query.exec("select coalesce(max(idpaciente),0) from paciente");
                 int maxId;

                 while (query.next())
                 {
                    maxId = query.value(0).toInt();
                 }
                 paci->setIdPaciente(maxId + 1);

            }

            paci->setCedula(ui->cedula->text().toInt());
            paci->setRuc(ui->ruc->text());
            paci->setNombre(ui->nombre->text());
            paci->setApellido(ui->apellido->text());
            paci->setSexo(ui->sexo->currentText());
            paci->setTelefono(ui->telefono->text());
            paci->setDireccion(ui->direccion->text());
            paci->setDir_facturacion(ui->direccionf->text());
            paci->setEstado("activo");
            paci->setEmail(ui->email->text());
            paci->setNombre_completo(paci->getNombre() + " " + paci->getApellido());

            if(ui->otraPatologia->isChecked()){

                Patologia *p = new Patologia(ui->nuevaPatologia->text());
                QSqlQuery query_pat;
                query_pat.exec("select coalesce(max(id_patologia),0) from patologia");
                int maxId;

                while (query_pat.next())
                {
                   maxId = query_pat.value(0).toInt();
                }
                p->setId_patologia(maxId + 1);

                p->save();
                paci->setPatologia(p);

            }
           else if (ui->patologia->currentText() == ""){
                Patologia *pat = new Patologia();
                QDjangoQuerySet<Patologia> patologias;
                pat = patologias.filter(QDjangoWhere("id_patologia", QDjangoWhere::Equals, 0)).at(0);
                if (pat == NULL)
                {
                       pat = new Patologia();
                       pat->setId_patologia(0);
                       pat->save();
                       paci->setPatologia(pat);
                }
            }
            else
            {
                QDjangoQuerySet<Patologia> patologias;
                Patologia *pat = new Patologia();
                pat = patologias.filter(QDjangoWhere("descripcion",QDjangoWhere::Equals,(ui->patologia->currentText()))).at(0);
                paci->setPatologia(pat);

            }

            if(ui->otroGrupo->isChecked()){
                GrupoPoblacional *grup = new GrupoPoblacional(ui->nuevoGrupo->text());

                QSqlQuery query_grupo;
                query_grupo.exec("select coalesce(max(id_grupopoblacional),0) from grupopoblacional");
                int max;

                while (query_grupo.next())
                {
                   max = query_grupo.value(0).toInt();
                }
                grup->setId_grupopoblacional(max + 1);

                grup->save();
                paci->setGrupopoblacional(grup);

            }
            else if (ui->grupo->currentText() == ""){

                GrupoPoblacional *grup = new GrupoPoblacional();
                QDjangoQuerySet<GrupoPoblacional> grupos;
                   grup = grupos.filter(QDjangoWhere("id_grupopoblacional", QDjangoWhere::Equals, 0)).at(0);
                   if (grup == NULL)
                   {
                       grup = new GrupoPoblacional();
                       grup->setId_grupopoblacional(0);
                       grup->save();
                       paci->setGrupopoblacional(grup);
                   }
            }
            else
            {
                QDjangoQuerySet<GrupoPoblacional> grupos;
                GrupoPoblacional *grupo = new GrupoPoblacional();
                grupo = grupos.filter(QDjangoWhere("descripcion",QDjangoWhere::Equals,(ui->grupo->currentText()))).at(0);
                paci->setGrupopoblacional(grupo);
            }

            paci->setFecha_nac(ui->fecha->date());

            paci->save();
            delete paci;
            this->close();

          }
      }
}



void Registro_mod_paciente::on_otraPatologia_clicked()
{
    ui->nuevaPatologia->setEnabled(true);

}

void Registro_mod_paciente::on_cancelar_clicked()
{
      this->close();
}

void Registro_mod_paciente::on_otroGrupo_clicked()
{
    ui->nuevoGrupo->setEnabled(true);
}
